home *** CD-ROM | disk | FTP | other *** search
/ CICA 1995 September (Japanese) / CICA Shareware for Windows CD-ROM (Walnut Creek) (September 1995) (Japanese) (Disc 2).iso / disc2 / nt / ntperf.exe / PERFTOOLS / SRC / PERFMON / DIVLARGE.C_ / DIVLARGE.C
Encoding:
C/C++ Source or Header  |  1993-02-11  |  2.6 KB  |  111 lines
  1. /*++
  2.  
  3. Module Name:
  4.  
  5.     divlarge.c
  6.  
  7. Abstract:
  8.  
  9.     This module implements the runtime library large integer divide
  10.     routines.
  11.  
  12.     N.B. These routines use a one bit at a time algorithm and is slow.
  13.          They should be used only when absolutely necessary.
  14.  
  15. Revision History:
  16.  
  17. --*/
  18.  
  19. #include "windows.h"
  20. #include "divlarge.h"
  21.  
  22. LARGE_INTEGER
  23. WINAPI
  24. LargeIntegerDivide (
  25.     IN LARGE_INTEGER Dividend,
  26.     IN LARGE_INTEGER Divisor,
  27.     OUT PLARGE_INTEGER Remainder OPTIONAL
  28.     )
  29.  
  30. /*++
  31.  
  32. Routine Description:
  33.  
  34.     This routine divides an unsigned 64-bit dividend by an unsigned 64-bit
  35.     divisor and returns a 64-bit quotient, and optionally a 64-bit remainder.
  36.  
  37. Arguments:
  38.  
  39.     Dividend - Supplies the 64-bit dividend for the divide operation.
  40.  
  41.     Divisor - Supplies the 64-bit divisor for the divide operation.
  42.  
  43.     Remainder - Supplies an optional pointer to a variable which receives
  44.         the remainder
  45.  
  46. Return Value:
  47.  
  48.     The 64-bit quotient is returned as the function value.
  49.  
  50. --*/
  51.  
  52. {
  53.  
  54.     ULONG Index = 64;
  55.     LARGE_INTEGER Partial = {0, 0};
  56.     LARGE_INTEGER Quotient;
  57.  
  58.     //
  59.     // Loop through the dividend bits and compute the quotient and remainder.
  60.     //
  61.  
  62.     Quotient = Dividend;
  63.     do {
  64.  
  65.         //
  66.         // Shift the next dividend bit into the parital remainder and shift
  67.         // the partial quotient (dividend) left one bit.
  68.         //
  69.  
  70.         Partial.HighPart = (Partial.HighPart << 1) | (Partial.LowPart >> 31);
  71.         Partial.LowPart = (Partial.LowPart << 1) | ((ULONG)Quotient.HighPart >> 31);
  72.         Quotient.HighPart = (Quotient.HighPart << 1) | (Quotient.LowPart >> 31);
  73.         Quotient.LowPart <<= 1;
  74.  
  75.         //
  76.         // If the partial remainder is greater than or equal to the divisor,
  77.         // then subtract the divisor from the partial remainder and insert a
  78.         // one bit into the quotient.
  79.         //
  80.  
  81.         if (((ULONG)Partial.HighPart > (ULONG)Divisor.HighPart) ||
  82.             ((Partial.HighPart == Divisor.HighPart) &&
  83.             (Partial.LowPart >= Divisor.LowPart))) {
  84.  
  85.             Quotient.LowPart |= 1;
  86.             Partial.HighPart -= Divisor.HighPart;
  87.             if (Partial.LowPart < Divisor.LowPart) {
  88.                 Partial.HighPart -= 1;
  89.             }
  90.  
  91.             Partial.LowPart -= Divisor.LowPart;
  92.         }
  93.  
  94.         Index -= 1;
  95.     } while (Index > 0);
  96.  
  97.     //
  98.     // If the remainder is requested, then return the 64-bit remainder.
  99.     //
  100.  
  101.     if (ARGUMENT_PRESENT(Remainder)) {
  102.         *Remainder = Partial;
  103.     }
  104.  
  105.     //
  106.     // Return the 64-bit quotient.
  107.     //
  108.  
  109.     return Quotient;
  110. }
  111.